Performance by Unified Model Analysis (PUMA)

Evaluation of non-functional properties of a design (such as performance, dependability, security, etc.) can be enabled by design annotations specific to the property to be evaluated. Performance properties, for instance, can be annotated on UML designs by using the UML Profile for Schedulability, Performance and Time (SPT) . However the communication between the design description in UML and the tools used for non-functional properties evaluation requires support, particularly for performance where there are many alternative performance analysis tools that might be applied. This paper describes a tool architecture called PUMA, which provides a unified interface between different kinds of design information and different kinds of performance models, for example Markov models, stochastic Petri nets and process algebras, queues and layered queues. The paper concentrates on the creation of performance models. The unified interface of PUMA is centered on an intermediate model called Core Scenario Model (CSM), which is extracted from the annotated design model. Experience shows that CSM is also necessary for cleaning and auditing the design information, and providing default interpretations in case it is incomplete, before creating a performance model

Integrating performance analysis in the model driven development of software product lines

The paper proposes to integrate performance analysis in the early phases of the model-driven development process for Software Product Lines (SPL). We start by adding generic performance annotations to the UML model representing the set of core reusable SPL assets. The annotations are generic and use the MARTE Profile recently adopted by OMG. A first model transformation realized in the Atlas Transformation Language (ATL), which is the focus of this paper, derives the UML model of a specific product with concrete MARTE performance annotations from the SPL model. A second transformation generates a Layered Queueing Network performance model for the given product by applying an existing transformation approach named PUMA, developed in previous work. The proposed technique is illustrated with an e-commerce case study that models the commonality and variability in both structural and behavioural SPL views. A product is derived and the performance of two design alternatives is compared

Tulsa: a tool for transforming UML to layered queueing networks for performance analysis of data intensive applications

Motivated by the problem of detecting software performance anti-patterns in data-intensive applications (DIAs), we present a tool, Tulsa, for transforming software architecture models specified through UML into Layered Queueing Networks (LQNs), which are analytical performance models used to capture contention across multiple software layers. In particular, we generalize an existing transformation based on the Epsilon framework to generate LQNs from UML models annotated with the DICE profile, which extends UML to modelling DIAs based on technologies such as Apache Storm

Transformation of UML Activity Diagram for Enhanced Reasoning

IT industry has adopted the unified modelling language activity diagram (UML-AD) as a de facto standard. UML AD facilitates modellers to graphically represent and document business processes to show the flow of activities and behaviour of a system. However, UML AD has many drawbacks such as lack of formal semantics i.e. ontology used for the constructs based on intuition, that vaguely describes processes and no provision for verifiability. Petri Net (PN) has been around for decades and used to model the workflow systems but PNs and its variants are too complex for business process modellers with no prior experience. A logical foundation is desirable to construct a business process with a precision that facilitates in transforming UML AD into a formal mechanism supported by verifiability capabilities for enhanced reasoning. Therefore, in this paper, we will provide a framework that will provide formal definitions for UML AD core terms and constructs used for modelling, and subsequently transform them to formal representation called point graph(PG). This will provide an insight into UML AD and will improve the overall functionality required from a modelling tool. A case study is conducted at King’s College Hospital trust’ to improve their patient flows of an accident and emergency (A&E) department

Assessing composition in modeling approaches

Modeling approaches are based on various paradigms, e.g., aspect-oriented, feature-oriented, object-oriented, and logic-based. Modeling approaches may cover requirements models to low-level design models, are developed for various purposes, use various means of composition, and thus are difficult to compare. However, such comparisons are critical to help practitioners know under which conditions approaches are most applicable, and how they might be successfully generalized and combined to achieve end-to-end methods. This paper reports on work done at the 2nd International Comparing Modeling Approaches (CMA) workshop towards the goal of identifying potential comprehensive modeling methodologies with a particular emphasis on composition: (i) an improved set of comparison criteria; (ii) 19 assessments of modeling approaches based on the comparison criteria and a common, focused case study

Software Performance Evaluation: Graph Grammar-based Transformation of UML Design Models into Performance Models

The quality of many software intensive systems is determined to a large extent by their performance characteristics, such as response time and throughput. The developers of such systems should be able to assess and understand the performance effects of various design decisions starting at an early stage, when changes are easy and less expensive, and continuing throughout the software life cycle. This can be achieved by constructing and analyzing quantitative performance models that capture the interact ions between the main system components and point to the system's performance trouble spots. The paper proposes a graph grammar-based transformation from UML design models into Layered Queueing Network (LQN) performance models. The LQN model structure is generated from the high-level software architecture showing the architectural patterns used in the system, and from deployment diagrams indicating the allocation of software components to hardware devices. The LQN model parameters are obtained from detailed models of key performance scenarios, represented as UML interaction or activity diagrams annotated with performance information (according to the recently proposed UML performance profile). The proposed transformation from UML to LQN was implemented with PROGRES, a well-known visual language and environment for programming with graph rewriting systems. The proposed technique was applied to the performance analysis of three CORBA-based client server systems, and the performance model results are reasonably close to measurements obtained from the actual implementations